2ª edição, revisada e ampliada

Apêndice G: Integração com .NET

IronPython é a implementação do interpretador Python na linguagem C#. Embora o projeto tenha como objetivo a compatibilidade com CPython, existem algumas diferenças entre elas. A principal vantagem do IronPython em relação ao CPython é a integração com componentes baseados no framework .NET.

O .NET é uma infra-estrutura de software criada pela Microsoft para a criação e execução de aplicações. A parte principal do .NET é o Common Language Runtime (CLR), que provê uma série recursos aos programas, como gerenciamento de memória para as aplicações. Além disso, há um vasto conjunto de bibliotecas de componentes prontos para uso. As instruções das linguagens de programação são traduzidas para intermediate language (IL) reconhecida pelo CLR, permitindo que várias linguagens sejam usadas.

Dentro dos recursos disponíveis no framework, existe o Dynamic Language Runtime (DLR), que implementa os serviços necessários para linguagens dinâmicas. O IronPython faz uso desses serviços.

Para evocar o modo interativo do IronPython:

ipy

Para executar um programa:

ipy prog.py

As bibliotecas do CPython podem ser usadas dentro do IronPython, desde que as versões sejam compatíveis.

Exemplo:



In [ ]:

    
import sys

# Acrescenta o caminho no PYTHONPATH
sys.path.append(r'c:\python25\lib')
import os
print os.listdir('.')

Exemplo usando um componente .NET:



In [ ]:

    
from System.Diagnostics import Process
Process.Start('http://www.w3c.org/')

A função Start irá evocar o browser para abrir a URL.

Os objetos .NET podem ser usados ao invés dos builtins do Python:



In [ ]:

    
import System
from System.Collections import  Hashtable

hash = Hashtable()
hash['baixo'] = '4 cordas'
hash['guitarra'] = '6 cordas'

for item in hash:
    print item.Key, '=>', item.Value

A classe Hashtable tem funcionalidade semelhante ao dicionário do Python.

Integração com outros componentes .NET adicionais, como o Windows Forms, que implementa a interface gráfica, é feita através do módulo clr. Após a importação do módulo, o IronPython passa a usar os tipos do .NET, ao invés da biblioteca padrão do Python.

Exemplo com Windows Forms:



In [ ]:

    
import clr

# Adiciona referências para esses componentes
clr.AddReference('System.Windows.Forms')
clr.AddReference('System.Drawing')

# Importa os componentes
from System.Windows.Forms import *
from System.Drawing import *

# Cria uma janela
frm = Form(Width=200, Height=200)

# Coloca título na janela
frm.Text = 'Mini calculadora Python'

# Cria texto
lbl = Label(Text='Entre com a expressão:',
    Left=20, Top=20, Width=140)
# Adiciona a janela
frm.Controls.Add(lbl)

# Cria caixa de texto
txt = TextBox(Left=20, Top=60, Width=140)
# Adiciona a janela
frm.Controls.Add(txt)

# Função para o botão
def on_btn_click(*args):
    
    try:
        r = repr(eval(txt.Text))
        MessageBox.Show(txt.Text + '=' + r, 'Resultado')

    except:
        MessageBox.Show('Não foi possível avaliar: ' + \
            txt.Text, 'Erro')

# Cria botão
btn = Button(Text='Calcular!', Left=20, Top=100, Width=60)
btn.Click += on_btn_click
# Adiciona a janela
frm.Controls.Add(btn)

# Mostra a janela
frm.Show()

# Aplicação entra no loop de eventos,
# esperando pela interação do usuário
Application.Run(frm)

Interface do programa:

O mais comum é usar herança para especializar a classe de janela, em uma solução mais orientada a objetos, encapsulando o código da criação e manipulação dos controles. A segunda versão do programa usa herança e inclui um componente de layout: FlowLayoutPanel.



In [ ]:

    
"""
Mini calculadora Python
"""
import clr

clr.AddReference('System.Windows.Forms')
clr.AddReference('System.Drawing')

from System.Windows.Forms import *
from System.Drawing import *

class Janela(Form):
    """
    Janela principal
    """
    def __init__(self):
        """
        Inicializa a janela
        """
        
        self.Width=200
        self.Height=200

        self.Text = 'Mini calculadora Python'

        self.lbl = Label(Text='Entre com a expressão:')

        self.txt = TextBox()

        self.btn = Button(Text='Calcular!')
        self.btn.Click += self.on_btn_click

        # Layout automático para os controles
        self.panel = FlowLayoutPanel(Dock = DockStyle.Fill)
        self.panel.Controls.Add(self.lbl)
        self.panel.Controls.Add(self.txt)
        self.panel.Controls.Add(self.btn)
        self.Controls.Add(self.panel)

        self.Show()

        Application.Run(self)

    def on_btn_click(self, *args):
        """
        Acontece quando o botão é pressionado
        """
        
        try:
            r = repr(eval(self.txt.Text))
            MessageBox.Show(self.txt.Text + ' = ' + r, 'Resultado')

        except:
            MessageBox.Show('Não foi possível avaliar: ' + \
                self.txt.Text, 'Erro')

if __name__ == '__main__':

    janela = Janela()

O IronPython pode ser usado com o Mono, que uma implementação Open Source da especificação do .NET. O Mono apresenta a vantagem de ser portável, suportando outras plataformas além do Windows, porém não implementa todos os componentes do .NET (como o Windows Forms). Existe também uma IDE para o IronPython, chamada IronPython Studio.



In [1]:









    Out[1]:

Python para Desenvolvedores

2ª edição, revisada e ampliada

Apêndice G: Integração com .NET